// Manejo del scroll tileado

PROCESS control_tiles()
//
// Controla la posicion del scroll de tiles
// Da la orden para dibujarlo en pantalla
// dependiendo el valor del ts.offset
//

PRIVATE
	int fpg_tiles;
	int text[10];
END

BEGIN

	ts.fpg = load_fpg ("fpg/tiles.fpg");

	LOOP
		
		// controla si el cursor pidio que se mueva EN X
		if ( ts.offset_x  <> 0)
			ts.dibujar = true;
			
			// calcula la nueva posicion del scroll en X
			if ( ts.offset_x > 0 )
				ts.x = ts.x  + ts.speed;
				ts.offset_x -= ts.speed;
			else
				ts.x = ts.x  - ts.speed;
				ts.offset_x += ts.speed;
			end
			
			// limita el movimiento en los margenes horizontales
			IF ( ts.x > (mapa.ancho * TILE_SIZE) - ts.width )
				ts.x = (mapa.ancho * TILE_SIZE) - ts.width;
			ELSEIF ( ts.x < 0 )
				ts.x = 0;
			END
		END
		
		// controla si se pidio que se mueva EN Y
		IF ( ts.offset_y <> 0  )
			ts.dibujar = true;
			
			// calcula la nueva posicion del scroll en Y
			if ( ts.offset_y > 0 )
				ts.y = ts.y  + ts.speed;
				ts.offset_y -= ts.speed;
			else
				ts.y = ts.y  - ts.speed;
				ts.offset_y += ts.speed;
			end
			
			// limita el movimiento en los margenes verticales
			IF ( ts.y > (mapa.alto * TILE_SIZE) - ts.height )
				ts.y = (mapa.alto * TILE_SIZE) - ts.height;
			ELSEIF ( ts.y < 0 )
				ts.y = 0;
			END
		END
		
		
		// DIBUJA EL SCROLL
		if (ts.dibujar )
			dibujar_tiles (ts.x,ts.y, 0);	
			ts.dibujar = false;
		end
		
		// muestra info de DEBUG
		text[0] = write ( 0, 0, 10, 0, "Scroll X: " + ts.x + ",  Y: " + ts.y);
		text[2] = write ( 0, 0, 20, 0, "EDITOR_DUREZAS: " + editor_durezas);
		
		if ( modo_editor )
			text[1] = write ( 0, 160, 240, 7, "EDITOR ACTIVADO (F2 desactivar)");
		else
			text[1] = write ( 0, 160, 240, 7, "F1 Activa Editor");
		end
	
		frame;
		
		delete_text( text[0] );
		delete_text( text[1] );
		delete_text( text[2] );
		
	END

END

//---------------------------------------------------------------------------------------
FUNCTION dibujar_tiles( offset_x, offset_y, dibujar_dureza )
//
// Se le pasa el punto superior izquierdo del scroll
// y dibuja la pantalla completa de tiles
//
// dibujar_dureza = 0 no dibuja, 1 dibuja solo durezas
//

PRIVATE
	// calcula los tiles iniciales
	int tile_min_x;
	int tile_min_y;
	
	// variables de trabajo
	int tile_x;
	int tile_y;
	
	// calcula los tiles a dibujar ( constante )
	int tiles_pantalla_x;
	int tiles_pantalla_y;
	
	// contadores
	int fila;
	int col;
END

BEGIN
	//limpia la pantalla de tiles anteriores
	if ( dibujar_dureza == false )clear_screen(); end
	
	// calcula los tiles iniciales
	tile_min_x = offset_x / TILE_SIZE;
	tile_min_y = offset_y / TILE_SIZE;
	
	// calcula los tiles a dibujar ( constante )
	tiles_pantalla_x =  ( ts.width / TILE_SIZE) + 1;
	tiles_pantalla_y = ( ts.height / TILE_SIZE ) + 2;
	
	// calcula que el tile no se salga de la matriz mapa
	// BUG SOLVED! :D
	if ( tile_min_x + tiles_pantalla_x > mapa.ancho )
		tile_min_x = mapa.ancho - tiles_pantalla_x;
	end
	if ( tile_min_y + tiles_pantalla_y > mapa.alto )
		tile_min_y = mapa.alto - tiles_pantalla_y;
	end
	
	//dibuja los tiles
	for ( col = tile_min_x; col < (tile_min_x + tiles_pantalla_x) ; col++ )
		for  ( fila = tile_min_y; fila < ( tile_min_y + tiles_pantalla_y ); fila++ )
		
			// calcula la posicion del tile en la pantalla
			tile_x = col * TILE_SIZE + 16 - offset_x;
			tile_y = fila * TILE_SIZE + 16 - offset_y;
			
			// comprueba si dibuja tile comun o de dureza
			if ( dibujar_dureza )
				// dibuja el tile
				put (fpg_sistema, mapa.durezas[col+(fila * mapa.ancho)], tile_x, tile_y);
			else
				// dibuja el tile
				put (ts.fpg, mapa.tiles[col+(fila * mapa.ancho)], tile_x, tile_y);
			end
			
			//frame;
		end
	end
	
	//informa que termino de dibujar
	ts.dibujar = false;

END

//---------------------------------------------------------------------------------------
PROCESS scroll_cursor()
//
// Cursor para moverse por el scroll
// La camara debe centrarse en este.
//
// Tambien tiene modo edicion
//

PRIVATE
	// coordenadas de posicion dentro del scroll
	int sx;	// en pixels
	int sy;
	
	// variables de movimiento (suave)
	int x_moviendo = false;
	int y_moviendo = false;
	int x_final;
	int y_final;
	int velocidad = 4;
	
	// variables para el modo editor
	editor_cursor;
	
	// textos en pantalla
	txts[5];
END

BEGIN

	file = 0;
	graph = load_png ( "png/cursor.png" );
	
	sx = TILE_SIZE * 5 + TILE_SIZE / 2;
	sy = TILE_SIZE * 3 + TILE_SIZE / 2;
	
	x_final = sx;
	y_final = sy;

	LOOP
		
		// Calcula si se apretan las teclas 
		IF ( key ( _right ) )
			IF ( x_final-sx < 4 AND tsCursor.tx+1 < mapa.ancho )
			// si le falta poquito para llegar al proximo tile, y no esta en el borde derecho del mapa
				x_moviendo = true;
				x_final += TILE_SIZE;
				// si esta en el borde de la pantalla, pide al scroll que se mueva
				// se usan directamente coordenadas de la pantalla
				if ( x > 8 * TILE_SIZE -1)
					ts.offset_x += TILE_SIZE;
				end
			END
		ELSEIF ( key ( _left ) )
			IF ( sx - x_final < 4 AND tsCursor.tx > 0)
				x_moviendo = true;
				x_final -= TILE_SIZE;
				// si esta en el borde de la pantalla, pide al scroll que se mueva
				if ( x < TILE_SIZE * 2 + 1)
					ts.offset_x -= TILE_SIZE;
				end
			END
		END
		
		IF ( key ( _down ) )
			IF ( y_final-sy < 4 AND tsCursor.ty + 1 < mapa.alto )
				y_moviendo = true;
				y_final += TILE_SIZE;
				// si esta en el borde de la pantalla, pide al scroll que se mueva
				if ( y > 6 * TILE_SIZE -1)
					ts.offset_y += TILE_SIZE;
				end
			END
		ELSEIF ( key ( _up ) )
			IF ( sy - y_final < 4 AND tsCursor.ty > 0)
				y_moviendo = true;
				y_final -= TILE_SIZE;
				// si esta en el borde de la pantalla, pide al scroll que se mueva
				if ( y < TILE_SIZE * 2 + 1)
					ts.offset_y -= TILE_SIZE;
				end
			END
		END
		
		
		// calcula el movimiento
		IF ( sx <> x_final)
			IF ( sx < x_final )
				sx += 4;
			ELSE
				sx -= 4;
			END
		ELSE
			x_moviendo = false;
		END
		IF ( sy <> y_final)
			IF ( sy < y_final )
				sy += 4;
			ELSE
				sy -= 4;
			END
		ELSE
			y_moviendo = false;
		END
		
		
		// MODO EDITOR
		if ( modo_editor )
			if ( editor_cursor == 0 )
				// llama al proceso editor_cursor
				editor_cursor = cursor_editor();
			end
		else
			if ( editor_cursor <> 0 )
				// elimina el proceso editor cursor
				signal (editor_cursor, S_KILL);
				editor_cursor = 0;
			end
		end
		
		
		// calcula el tile de posicion
		tsCursor.tx = x_final / TILE_SIZE;
		tsCursor.ty = y_final / TILE_SIZE;
		
		// actualiza la posicion en pantalla
		x = sx - ts.x;
		y = sy - ts.y;
		
		// muestra info de DEBUG
		txts[0] = write ( 0, 320, 10, 2, "Cursor: " + tsCursor.tx + ";" + tsCursor.ty );
		txts[1] = write ( 0, 320, 20, 2, "X: " + sx + " (" + x_final + ") (" + x + ")");
		txts[2] = write ( 0, 320, 30, 2, "Y: " + sy + " (" + y_final + ") (" + y + ")");
	
		frame;
		
		delete_text ( txts[0] );
		delete_text ( txts[1] );
		delete_text ( txts[2] );
		
	END

END

//---------------------------------------------------------------------------------------
PROCESS cursor_editor()
//
// Muestra el tile actual en el modo editor
// Guarda el mapa si se lo pide
//

PRIVATE
	// seleccion de tiles
	tile_seleccionado = 2;
	tiles_total = 9;
	
	puede_seleccionar = true;
	
	//timer parpadeo
	timer = 0;
END

BEGIN

	file = ts.fpg;

	LOOP
	
		x = father.x;
		y = father.y;
		graph = tile_seleccionado;
		
		//debug;
		if (editor_durezas == false )
			
			// Seleccion de tile
			if ( puede_seleccionar )
				if ( key ( _Q ) )
					tile_seleccionado--;
					puede_seleccionar = false;
					if ( tile_seleccionado < 1 )
						tile_seleccionado = tiles_total;
					end
				elseif ( key ( _E ) )
					tile_seleccionado++;
					puede_seleccionar = false;
					if ( tile_seleccionado > tiles_total )
						tile_seleccionado = 1;
					end
				end
			else
				if ( NOT key ( _Q ) and not key ( _E ) )
					puede_seleccionar = true;
				end
			end
			
			// edita el mapa
			if ( key ( _SPACE ) )
				mapa.tiles[tsCursor.tx+ (tsCursor.ty * mapa.ancho)] = tile_seleccionado;
				ts.dibujar = true;
			end
		
		else	// editor_dureza = true
		
			//dibuja las durezas a cada frame;
			dibujar_tiles (ts.x,ts.y, 1);
		
		end
		
		// CARGA MAPAS
		IF ( key ( _f9 ) )
			IF ( file_exists ( "maps/map1.dat" ) )
				load("maps/map1.dat", mapa);
				ts.dibujar = true;
			END
		END
		IF ( key ( _f10 ) )
			IF ( file_exists ( "maps/map2.dat" ) )
				load("maps/map2.dat", mapa);
				ts.dibujar = true;
			END
		END
		
		// GUARDA MAPAS
		IF ( key ( _f11 ) )
			save("maps/map1.dat", mapa);
		END
		IF ( key ( _f12 ) )
			save("maps/map2.dat", mapa);
		END
		
	
		frame;
		
	END

END

//---------------------------------------------------------------------------------------
PROCESS editor_ayuda()
//
// muestra la ayuda en pantalla
// carga un png

BEGIN
	file = 0;
	graph = load_png ( "png/controles.png" );
	LOOP
		if ( modo_editor )
			x = 100; y = 100;
		else
			x = -200; y = -200;
		end
		frame;
	END
END

